New Star Software Collection/NSS_Collection.iso/3-069 qemm 603/1.ima/DVMAN/CH6.DEV

Text File | 1991-10-08 | 30.3 KB | 806 lines

Chapter 6

Advanced Mark and Transfer

 DESQview's basic mark and transfer feature lets you mark a block
of information and transfer it to another program, or to another
point in the same program. See pages 58-59 of Chapter 3, Using
DESQview, for a discussion of the basic mark and transfer
process. When you mark multiple lines of information, you can
specify a number of powerful advanced operations that affect mark
and transfer:

~Item~ You can mark and transfer disjoint blocks of information,
that is,  mark contiguous information as separate pieces, or
"lines." (See The Concept of Marked Lines, on the next page.) You
can do this so the lines may be  handled specially when
transferred, for instance, to reformat them.

~Item~ You can mark non-contiguous information from different
snapshots (from the same or several different DESQview windows)
which may be gathered together, as disjoint information, into the
transfer buffer. Once combined, the disjoint information can be
tranferred to another program in a single step.

~Item~ You can mark and transfer repeating patterns of
information ~dash~ for example, records in a database or rows and
columns in a spreadsheet.

~Item~ You can use DESQview's Learn feature with mark and
transfer to create scripts (keystroke macros) that transfer
information from one program to another, processing the
information as you transfer.

~Item~ You can use the Scissors command to transfer information
between programs written expressly for DESQview ~dash~ if both
the source and destination programs support the Scissors
capability.

This chapter explains how to use these advanced features by
walking you through two examples:

~Item~ The first example describes how you would mark and
transfer disjoint blocks of information by transferring
information from a database (dBASE III Plus) to a word processor
(WordPerfect) in "mailing label" format.

~Item~ The second example describes how you would mark and
transfer rows and columns of information by transferring
information downloaded from a mainframe with a communications
program to a spreadsheet program (Lotus 1-2-3 Release 2).

 This chapter is for advanced users. You should familiarize
yourself with the basic mark and transfer process on pages 58-59
and Chapter 5, Learn: DESQview's Keystroke Macro Feature, before
reading this chapter.

~Heading~ Transferring Disjoint Blocks of Information

 The basic mark and transfer process (that you learned about in
Chapters 2 and 3) described the steps to mark and transfer a
single block of information:

~Item~ Mark the block of information, using Mark Begin and DONE.

~Item~ Switch to the program where you want to transfer the
information, put the cursor at the transfer point, and select
Transfer.

~Item~ Press <Enter> to transfer the block of information you
marked into the program in the same format ~dash~ namely, as
multiple lines of text.

In addition, DESQview gives you the following advanced
capabilities:

~Item~ You can mark more than one block of information to be
transferred within a single screen snapshot.

~Item~ You can mark blocks in different snapshots and combine
them into a single transfer operation.

~Item~ You can mark a set of disjoint blocks and then repeat the
same sequence of steps to mark additional blocks with the same
pattern. For example, after you've marked columns 2, 4, and 6 in
row 4 of a spreadsheet, you could tell DESQview ~dash~ with a
keystroke macro ~dash~ to repeat this marking pattern on rows 5
through 15.

~Item~ You can type a specific key sequence at the beginning of
each line you transfer ~dash~ in addition to the key sequence you
type at the end of each line.

~Item~ You can specify a different keystroke before/keystroke
after sequence between marked blocks, rather than using the same
sequence for each block.

~Item~ You can transfer the same marked information more than
once. For example, after marking fields in a database, you could
transfer the information to a spreadsheet program and then to a
word processing program. Information stays in the transfer buffer
until you exit mark mode, then start another mark operation.

~Subhead~ Disjoint Blocks: Defining theProblem

 The best way to understand DESQview's advanced capabilities is
to walk through an example. The example we'll use is building a
set of mailing address labels from a database of names and
addresses. We'll use a sample database called NAMES and we'll
construct the mailing labels in WordPerfect.

The NAMES database consists of 10 records, as follows:

Begin Table

 FIRST NAME, LAST NAME, ADDRESS, CITY, STATE, ZIP CODE

 Luann, Neuhoff, 8653 Rita Drive, Bloomington, IN, 47401

 Claire, Buckman, 8307 Santa Anita Blvd, Oxnard, CA, 93034

 Hank, Bicksby, 4101 Peonia Rd, Flagstaff, AZ, 86001

 Lena, Garnett, 520 S. 8th St., Reno, NV, 89504

 Lisa, Kafmanan, 1960 Lindley Avenue, Reseda, CA, 91355

 Jay, Johnson, 14234 Riverside Dr., Riverside, CA, 92504

 Sara, Collins, 303 W. Milford St., Portland, OR, 97215

 Rick, Zambini, 108 Prairie, Woodland Hills, CA, 91364

 Kim, Arlich, 10564 Ventura Blvd., Long Beach, CA, 90806

 John, Montovan, 1034 Lorraine St., Culver City, CA, 90230

 Vicky, Gorman, 203 E. 3rd St. S., Mesa, AZ, 85201

~End Table~

The format of a mailing address label is:

     Luann Neuhoff
     8653 Rita Drive
     Bloomington, IN 47401

~Subhead~ Disjoint Blocks: Defining the Steps

 For this example, we'll assume that you've started dBASE III
Plus running in window 1 and issued the command USE NAMES. Also
we'll assume that you've started WordPerfect running in window 2
and that it's ready to receive information.

Overall, the way we want the database-to-mailing-label procedure
to work is this:

~Item~ First, use the EDIT n command in dBASE III Plus to display
the first record you want to transfer.

~Item~ Second, tell DESQview to mark the record and transfer it
into the format of a mailing label in the WordPerfect window.

 Third, switch back to the dBASE III Plus window so you can
display the next record to transfer.

To perform this procedure, we'll use DESQview's advanced mark and
transfer features in combination with DESQview's Learn command.
The basic steps are:

~Item~ Starting with dBASE III Plus as the current window, use
the EDIT n command to display the first record you want to
transfer.

~Item~ Perform DESQview's Start Script command to start learning
a script.

~Item~ Use DESQview's Mark command to mark the 6 fields in the
database in the order you want them to appear in the address
label: FIRSTNAME, LASTNAME, ADDRESS, CITY, STATE, ZIPCODE.

~Item~ Switch to WordPerfect and use DESQview's Transfer command
to transfer the 6 fields into WordPerfect in the format of an
address label.

~Item~ Switch back to dBASE III Plus

~Item~ End the Learn.

Now, you have a script that performs the desired transfer and
reformatting of information. To transfer another record:

~Item~ Use the PgUp and PgDn keys ~dash~ or whichever dBASE III
Plus commands you prefer ~dash~ to display the next record you
want to transfer.

~Item~ Perform the script.

Repeat these two steps until all the records you want are
transferred.

~Subhead~ Disjoint Blocks: Marking the Blocks

 To begin, open a dBASE III Plus window and display record 1 of
the NAMES database. Then open a WordPerfect window and switch
back to dBASE III Plus.

~Step~ Open dBASE III Plus as window 1. Then enter the "USE
NAMES" command, followed by the "EDIT 1" command.

~Step~ Open WordPerfect as window 2. Then switch back to window 1.

Now, start learning a script which will be assigned to the Alt-A
key:

~Step~ Display the Learn menu (Shift-DESQ) and select Start
Script. Then press the Alt-A key, type Address Label for the
script name, and press <Enter>.

Now mark the 6 fields:

~Step~ Display the Mark menu.

~Step~ Move the cursor to the FIRSTNAME field and mark it ~dash~
but end the Mark by selecting Mark End rather than DONE. Be sure
that you mark all 10 characters of the field, not just the name
"Luann."

 When you select Mark End, the Mark menu remains on the screen
and "mark mode" remains in effect so you can mark more blocks.
You need to mark the entire field, not just "Luann," because
you're going to repeat this marking step on other FIRSTNAME
fields, some of which are longer than "Luann."

~Step~ Mark the remaining 5 fields in the order: LASTNAME,
ADDRESS, CITY, STATE, ZIPCODE ~dash~ again, to be sure to end
each Mark by using Mark End rather than DONE and to mark the
entire field.

Now that all 6 fields are marked and remembered by DESQview,
you're ready to transfer this information into WordPerfect.

~Subhead~ Disjoint Blocks: Transferring the Blocks

 To transfer the information to WordPerfect:

~Step~ Switch to window 2 and display the Transfer menu.

~Step~ Select "Transfer the first line."

Now you must indicate the key (or keys) you want typed between
the first field (FIRSTNAME) and the second field (LASTNAME):

~Step~ Type a space. Then tap the DESQ key to indicate that
you've entered all the keystrokes (in this case, just one, the
spacebar character) you want between the two fields.

 A space appears after "Luann" and the Transfer menu reappears.
Notice that DESQview has deleted the "trailing blanks" ~dash~
that is, the blanks at the end of the field.

Next transfer the 5 remaining fields in the following sequence,
with the following intervening keystrokes:

~Step~ Select "Transfer the next line," type the appropriate key
or keys (as shown below), and tap the DESQ key.

~Begin Table~

 after, LASTNAME, type, <Enter>
 after, ADDRESS, type, <Enter>
 after, CITY, type, a comma and one space
 after, STATE, type, two spaces
 after, ZIPCODE, type, two <Enter>

~End Table~

Finally, switch back to dBASE III Plus and end the Learn:

~Step~ Switch to window 1, display the Learn menu (Shift-DESQ),
and select Finish Script.

~Subhead~ Disjoint Blocks: Transferring More records using a
script

 To transfer additional records:

~Step~ Use the PgDn or PgUp key to display the next record you
want to transfer.

~Step~ Press Alt-A

~Step~ Repeat these steps until all the records you want are
transferred.

~Heading~ Transferring Rows and Columns

 The discussion on the preceding several pages, Transferring
Disjoint Blocks of Information, examines the case of marking and
transferring disjoint blocks of information. Another frequent use
of mark and transfer is to transfer rows and columns of
information into a spreadsheet program.

~Subhead~ Rows and Columns: Defining the Problem

 The best way to understand how to transfer rows and columns is
to walk through an example. The example we'll use is having a
communications program download and capture some revenue
information from your mainframe and then transfer it into Lotus
1-2-3 Release 2.  Since we don't have a mainframe handy, let's
assume that your mainframe produces a table in the format shown
below ~dash~ namely, the information in Sample Spreadsheet.

~Begin Table~

                    Jan      Feb       Mar      Apr      May     Jun
ASSETS
Accts Receivable, $1,000.0  $1,050.0  $1,102.5 $1,157.6   $1,215.5  $1,276.2
   Cash              300.0     500.0     525.0    551.2      578.8     607.7
   Unsold Goods      250.0     262.5      65.6    289.4      303.8     319.0
   TOTAL ASSETS   $1,550.0  $1,812.5   $1,693.1 $1,998.2  $2,098.1  $2,202.9
LIABILITIES
Accts Payable     $1,000.0   $ 916.6  $  840.2  $  770.2  $  706.0  $  647.2
 Storage Costs        50.0      50.0      50.0      50.0      50.0      50.0
 Labor                100.0    105.0     110.2     115.7     121.5     127.6
 Materials             50.0     52.5      55.1      57.8      60.7      63.8
 TOTAL LIABILITIES $1,200.0 $1,124.1  $1,055.5   $ 993.7   $ 938.2   $ 888.6

NIBT           $  350.0 $  688.4  $  637.6    $1,004.5 $1,159.9  $1,314.3
 Dep. Allowance          100.0    100.0     100.0       100.0     100.0    100.0
 Taxable Income       250.0    588.4     537.6     904.5   1,059.9   1,214.3
 Taxes(@30%)           75.0    176.5     161.3     271.4     318.0     364.3

NET INCOME         $  275.0 $  511.9  $  476.3  $  733.2  $  841.9 $   950.0

~End Table~

Let's also assume that 1-2-3 is set up in the format show below:

For this example, we'll assume that you've started Sample
Spreadsheet running in window 1 and Lotus 1-2-3 Release 2 in
window 2.  Overall, the way we want the table-to-spreadsheet
procedure to work is this:

~Item~ First mark the top-most line of information in the table
(skipping the months and the ASSETS line), recording the
keystrokes you enter as a script.

~Item~ Second, use this script to mark the remaining lines in the
table.

~Item~ Third, switch to 1-2-3, enter the header information in
columns A-G of lines 1-3, and then transfer the table all at once
into 1-2-3.

To perform this procedure, we'll use DESQview's advanced mark and
transfer features in combination with DESQview's Learn command.
The basic steps are:

~Item~ Starting with Sample Spreadsheet as the current window,
display the Mark menu.

~Item~ Skipping the months row, position the cursor at the
beginning of the "Accts Receivable" row ~dash~ 1 row under the A
in ASSETS. Then start a Learn.

~Item~ First, mark the label itself ~dash~ "Accts Receivable."
Then mark each of the 6 columns of numbers in turn.

~Item~ Position the cursor at the beginning of the "Cash" line.
(Be sure to use the arrow keys, not <Enter>, to move the cursor
to the beginning of the next line.  Remember, pressing <Enter>
ends the Mark command.)

~Item~ End the Learn.

~Item~ Use the script you just created to mark the remaining 17
lines (including the 3 blank lines).

~Item~ Switch to Lotus 1-2-3 Release 2, type in the header
information in columns A-G of rows 1-3, and then position the
spreadsheet cursor at A4.

~Item~ Tell DESQview to transfer the first marked line ~dash~
"Accts Receivable" ~dash~ as text (using the Transfer the first
line command).  Then type a right arrow.

~Item~ Next, tell DESQview to transfer the next 6 blocks as
numbers.  Separate all but the last block by a right arrow. After
the last block, put 6 left arrows and a down arrow to move the
cursor to A5, the beginning of the next row.

~Item~ Use Transfer the rest of your data to transfer the
remaining 17 rows.

~Subhead~ Rows and Columns: Defining the Blocks

 To begin, open a Sample Spreadsheet window:

~Step~ Open Sample Spreadsheet as window 1.

~Step~ Display the Mark menu.

~Step~ Position the cursor at the beginning of the "Accts
Receivable" row ~dash~ under the "A" of "ASSETS".

Now, start learning a script which will be assigned to the Alt-M
key:

~Step~ Display the Learn menu (Shift-DESQ) and select Start
Script.  Then press the Alt-M key, type Mark Line for the script
name, and press <Enter>.

Next, mark the label field:

~Step~ Mark the "Accts Receivable" entry ~dash~ but end the Mark
by selecting Mark End rather than DONE. Be sure to mark all 20
characters, through the column just before the dollar sign ($).

 When you select Mark End, the Mark menu remains on the screen
and "mark mode" remains in effect so you can mark more blocks.
You need to mark the entire label field, not just "Accts
Receivable", because you're going to repeat this marking step on
other entries, some of which are longer than "Accts Receivable".

~Step~ Mark the number "$1,000.0", starting in the dollar sign
and extending through the ".0" of "$1,000.0" ~dash~ 8 characters.

~Step~ Mark the remaining 5 numbers (Feb-Jun) in the same way, as
8- column wide entries.

~Step~ Position the cursor at the beginning of the "Cash" line.
Use the arrow keys to move the cursor, not the <Enter> key.

Now all 7 fields are marked and remembered by DESQview and the
cursor is positioned at the beginning of the next field. So, end
the Learn:

~Step~ Display the Learn menu (Shift-DESQ) and select Finish
Script.

Now, mark the remaining 17 rows of Sample Spreadsheet and end
marking:

~Step~ Press Alt-M 17 times to mark the remaining 17 rows.

~Step~ Select DONE to end marking.

~Subhead~ Rows and Columns: Transferring the blocks

 To transfer the information, open a 1-2-3 window. Then, set up
columns A-G, type the appropriate information in rows 1-3, and
prepare to start the transfer:

~Step~ Open Lotus 1-2-3 Release 2 as window 2.

~Step~ Type this six months in columns B-G of row 1 by typing Jan
<Enter>, and so forth.  Type hypens in columns B-G of row 2 by
typing "- - - - - --<Enter>. And, type the word "ASSETS" in cell
A3 by typing ASSETS <Enter>.

~Step~ Position the spreadsheet cursor at A4. Then, set column A
to 20 wide by typing /Worksheet Column Set-Width 20 <Enter> and
indicate you want numbers set to 1 decimal place by typing /
Worksheet Global Format Fixed 1 <Enter>.

~Step~ Display the Transfer menu.

Now you must indicate that you want to insert text before the
first field ~dash~ in this case, a quotation mark to guarantee
that the label is transferred to 1-2-3 as text, even if it starts
with a number:

~Step~ Select "Type keys to begin each line."


~Step~ Type a double quote mark (").

~Step~ Tap the DESQ key to indicate that you've entered all the
text you want to insert before the transferred field.

" appears on the 1-2-3 data entry line. Now, transfer the text
label field:

~Step~ Select "Transfer the next line."

DESQview will ask which characters to insert between lines

~Step~ Press right arrow to indicate you want to move the cursor
one cell to the right after the label is transferred. (This
transfers "Accts Receivable" and moves the cursor to B4.)

~Step~ Tap the DESQ key to complete the keystroke insertion
command for the first transfer.

This redisplays the Transfer menu.  Next, Transfer the 6 numeric
fields:

~Step~ Select "Transfer the next number."

This tells DESQview that the next block is a number and it should
not transfer the dollar signs or commas from the text file
(Sample Spreadsheet is really a text file), even though they were
included in the mark operation.  DESQview will filter these
characters before the number is placed in the spreadsheet cell.
When DESQview transfers a number with this command, any
nonnumeric characters except periods and minus signs are removed
and a leading left parentheses is converted to a minus sign.

You will see 1000.0 on the 1-2-3 data entry line:

~Step~ Press right arrow to place the number in the cell, This
transfers "$1,000.0" as a number ~dash~ namely as "1000.0" ~dash~
into cell B4.

~Step~ Tap the DESQ key to complete the keystroke insertion.

~Step~ Repeat the last two steps four more times to transfer the
information for Feb-May.

For the June column, you'll want to  move the cursor to the
beginning of the next row after the transfer, to start the next
row ("Cash.") You'll tell DESQview to do this by entering all the
keystrokes needed to navigate to cell A5 after the June column
has been transferred:

~Step~ To transfer the "Jun" value, select "Transfer the next
number."

~Step~ Press the down arrow once, press the left arrow six times,
(This places the number, "1276.2", into cell G4 and moves the
cursor to A5.)

~Step~ Tap the DESQ key to complete the keystroke insertion
sequence.

Note that you specified seven keystrokes to be executed when
transferring the cells in last column. Finally, to transfer all
the remaining 17 lines you marked:

~Step~ Select "Transfer the rest of your data."

The transfer program has memorized the pattern of keystrokes
before and keystrokes after each transferred insertion relative
to the sequence you have just performed. Each"first-in-the-row"
cell will be inserted as a text label, followed by six numeric
insertions and keystrokes to navigate to the beginning of the
next spreadsheet row. The result is the following 1-2-3
spreadsheet:

~Heading~ Additional Mark and Transfer Features

 In addition to the features already discussed in this chapter
(and on pages 58-59), there are two other Mark and Transfer
featrues:

~Item~ There's a shortcut for marking and transferring a block of
numbers.

~Item~ Information in several snapshots can be combined and then
transferred in a single step ~dash~ using the Mark More command.

~Subhead~ Transferring a Block of Numbers

 Normally, there's a one-to-one correspondence between the number
of blocks you mark and the number of transfer commands needed to
transfer the blocks.  If you mark 10 blocks, you issue 10
transfer commands.

However, DESQview has a shortcut for marking and transferring
numbers.  You can mark an entire row or rectangular block of
numbers (for example, 20 rows of 10 columns) and then transfer
each number in the block separately.  When you select Transfer
the first number, the first number in the first block is
transferred.  Then, each time you select Transfer the next
number, the next number in the same block is transferred ~dash~
or, the next number in the next block is there are no more
numbers in the current block.

To use this shortcut, the block of numbers you mark must not
contain any blank entries or blank lines. Also, numbers are
edited to remove all nonnumeric characters except periods and
minus signs, and to convert a left paretheses to a minus sign.

 You can often substitute this shortcut for the procedure given
in Transferring Rows and Columns ~dash~ although not in that
particular example, because Sample Spreadsheet contains blank
lines.

For example, if you have a table in DESQview Notepad that
consists of 20 rows of 10 columns of numbers (without entries or
blank lines), to transfer this table into 1-2-3 in the same
(20x10) format:

~Step~ Transfer the first number with the "Transfer the first
number" command ~dash~ followed by a "right arrow" (to move the
cursor to the next column).

~Step~ Transfer the next 8 numbers with the "Transfer the next
number" command ~dash~ following each number by a "right arrow."

~Step~ Transfer the 10th number with the "Transfer the next
number" command ~dash~ followed by 9 "left arrows" and a "down
arrow" (to move the spreadsheet cursor to the beginning of the
next row).

~Step~ Transfer the remaining 19 rows with the "Transfer the rest
of your data" command.

 If the table has labels, mark three blocks:  top labels, left
labels, and the block of numbers. First, transfer the two sets of
labels using the Transfer the first line command.  Then, transfer
the block of numbers using the steps given above.

~Subhead~ Combining Blocks of Information Using the Mark More
Command

 Normally, all the information you mark must be entirely
contained in the current snapshot.  The Mark More command lets
you overcome this limitation and mark information contained in
several snapshots:

~Item~ When the first command you issue after you display the
Mark menu is Mark Begin, DESQview discards anything you
previously marked and starts over with an empty "mark buffer."

~Item~ When the first command you issue after you display the
Mark menu is Mark More, DESQview appends whatever you mark to the
"mark buffer".

 Thus, by using Mark Begin on the first snapshot and Mark More on
subsequent snapshots, you can mark information in multiple
snapshots. See the example , Building a Mark and Transfer Super-
script below.

 The amount of information you can mark is limited by the amount
of "common" memory that's currently available (see Appendix A).
"Common" memory is the area of memory DESQview needs to manage
window and save the information you mark. If you intend to mark
more than a single full (25x80) screen's worth of information,
you should increase the size of the Common Memory buffer before
you start up DESQview ~dash~ by 2K per additional screenful.

Except as the first command, Mark More and Mark Begin are
equivalent.

~Subhead~ Building a Mark and Transfer Super-Script

 The Transferring Rows and Columns section of this chapter
explains how to transfer a table from a word processing program
(Sample Spreadsheet) to a spreadsheet program (1-2-3 Release 2).
It's limited, however, to transferring a table that fits entirely
in one snapshot.

You can extend this procedure so that it marks a table that
extends over multiple snapshots, and then transfers this table in
a single step. Using DESQview's embedded learn capability, you
can even build a script that performs this entire process with a
single keystroke.

For example, let's assume that Sample Spreadsheet, which is 18-
lines by 7-columns (excluding the heading), is just the beginning
of a 200-line table that's been loaded into DESQview Notepad.
And, let's also assume that you download this table every day
(with different numbers) and thus want to be able to transfer it
into 1-2-3 with a single keystroke.

~Step~ With Notepad as the current window, and the cursor at the
beginning of the "ASSETS" line, start learning a script ~dash~
call it Move Table.

~Step~ Then, immediately embed another learn ~dash~ call it Init
Table ~dash~ that marks the word "ASSETS" (using Mark Begin),
moves the cursor down to the beginning of the "Accts Receivable"
line, then terminate the learn by performing the Finish Script
command.

 The trick to creating a script that works across multiple
snapshots is, first, to create an initialization script that
clears the "mark buffer" using Mark begin and, then, to mark the
information using only Mark More.

~Step~ Now immediately start another script ~dash~ call it Mark
Page ~dash~ and then follow the steps on page 103, Rows and
Column:  Defining the Blocks, to mark the 18 lines of information
visible ~dash~ but using Mark More instead of Mark Begin.

 When you select DONE on the Mark menu, Notepad resumes running.
So:

~Step~ Press PgDn (or whatever) to display the next screen's
worth of the table and align the cursor so it's at the beginning
of the next unmarked row ~dash~ initially, the 19th row, just
below "NET INCOME."

~Step~ Use the Time Delay command to insert a one-second delay in
the script.

 Inserting a time delay ensures that, when you play back the
script, Notepad will have time to completely display the page on
the screen before the script continues.

~Step~ End the Mark Page script.

~Step~ Play back Mark Page repeatedly until all 200 lines have
been marked.

 To be sure the last iteration works correctly, you should add 18
extra lines (of 80 spaces each) to the end of the table before
you start this procedure.

~Step~ Switch to 1-2-3, set up the heading information (see pages
103-106), set the cursor to A3, and transfer "ASSETS".

~Step~ Display the Transfer menu and follow the steps on page 100
to transfer all of the 200 lines you marked into 1-2-3 at one
time.

~Step~ End the script Move Table.

 Now, to transfer another instance of a 200-line table into 1-2-3
with a single keystroke:

~Step~ Load the table into DESQview Notepad, put the cursor at
the beginning of the "ASSETS" line, and play back the Move Table
script by pressing the key you assigned it to.

 If you're using DESQview Notepad (or if your word processor can
write a column to a text file), a more efficient method is to
create a script that writes the 200 labels to one file, the
(200x7) block of numbers to another file, and then switches to 1-
2-3 and uses Import Text to read in the labels and Import Numbers
to read in the numbers.  (Use the file names DESQTMP1 and
DESQTMP2 to avoid file-naming problems ~dash~ see Appendix E.)

 This procedure uses doubly nested embedded learns: Move Table
(TM) Init Table (TM) Mark Page. Mark Page and Init Table are
actually relearned every time you play back Move Table. However,
you'll hardly notice it, because it happens so fast.

~Heading~ Scissors

The Scissors command allows you to perform mark and transfer
operations using Copy, Cut, and Paste instead of Mark and
Transfer. Scissors differs from Mark and Transfer in that:

~Item~ Both the program that you mark the information in and the
program that you transfer the information to must have been
written expressly for DESQview using a DESQview API, and, also,
must explicitly support the Scissors command

~Begin footnote~

A program supports the Scissors command only if an X appears on
the Scissors line when you display the DESQview menu while the
program is running.  Programs written expressly for DESQview by
Quarterdeck ~dash~ such as Add a Program, Change a Program,
DESQview Companions, and so forth ~dash~ do not support the
Scissors command.

~End footnote~

~Item~ You can only mark a single block of information in a
single snapshot.

~Item~ The information you mark can be manipulated by the program
running in the window before it's saved. For example, if you
marked cells in a spreadsheet, the program could copy the
underlying formulas rather than the contents of the cells ~dash~
if it wanted to. Similarly, the program determines how
information is deleted when you use the Cut command.

~Item~ The Paste operation is performed entirely by the program.
It can type in the information, as Transfer does, or perform
whatever other type of transfer it desires. For example, if you
transfer formulas from another spreadsheet program, it could
convert them into its own formula format.

To use Scissors:

~Step~ Display the DESQview menu and select Scissors to display
the Scissors menu.

~Step~ Select the Copy or Cut command to display the Copy or Cut
menu and cause the mouse cursor ~dash~ a diamond ~dash~ to appear
in the current window.

Then, proceed in the same manner as for the Mark command:

~Step~ Move the mouse cursor to the first character of the text
you want to copy or cut and select Mark Begin. Then move the
cursor until the reverse video box encloses the last character of
the block you want, and select Mark End.

Then, to paste the marked block of information:

~Step~ Switch to the program where you want to paste the block,
display the DESQview menu, select Scissors to display the
Scissors menu, and then select Paste to display the Paste menu
and the block of text you marked.

~Step~ Move the block of text around until it's positioned at the
point where you want it to be pasted. Then, select DONE.

Remember, it's up to the program how it performs the paste
operation.